<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
</head>

<body>
    <script>
        /*----------------对象的创建------------------*/
        //原始模式 *
        let person = new Object()
        //上下两种创建对象的方式是等效的
        // let person = {}
        //属性
        person.name = 'albert'
        person.say = function () {
            console.log(`hello i am ${this.name}`)
        }
        function hi() {
            console.log('hi')
        }
        function foo() {
            console.log('i am foo')
            return "foo"
        }
        //增加方法
        person.sayHi = hi
        person.foo = foo
        person.bar = function () { console.log('bar') }

        //工程模式，理解即可，开发过程中不经常使用
        function createPerson(name, age) {
            //生成一个空对象
            let person = {}
            //给对象赋值属性或者方法
            person.name = name
            person.age = age
            //返回这个对象
            return person
        }
        //缺陷：脱离对象原型。
        let jim = createPerson('jim', 12)

        //构造函数模式，重点掌握
        function Person(name, age) {
            //this指即将要创建对象的实例
            this.name = name
            this.age = age
            this.hello = function () {
                console.log('hello i am  ' + this.name)
            }
            this.grade = 6
        }
        //每一个构造函数都有一个 prototype 属性，指向另一个对象。这个对象的所有属性和方法，都会被构造函数的实例继承

        // Person.prototype是一个对象，这个对象能被所有的实例访问，这个对象里面的所有属性和方法都会被实例继承
        //给构造函数Person的原型（Person.prototype）添加一个新的属性，这个属性会被构造函数创建的所有实例所继承
        // Person.prototype.bar = function(){
        //     console.log('i am bar')
        // }
        //Person.prototype.good = "i am good"

        //通过new Person 传入参数，生成新的对象实例
        let jack = new Person('jack', 18)
        jack instanceof Person //true,判断jack是否是Person的一个实例，也就是说jack是否是由Person构造函数所创建的
        let lucy = new Person('lucy', 10)
        //普通方式创建对象，缺点是当需要创建多个同类型对象时代码繁多，不容易维护。
        let lily = {
            name: "lily",
            age: 12,
            hello: function () { console.log('hello') },
            grade: 6
        }
        lily instanceof Person //false
        let rose = {
            name: "rose",
            age: 11,
            hello: function () { console.log('hello') },
            grade: 6
        }
        //构造函数优势：
        //1.统一创建实例的属性和方法。
        //2.便于批量创建同类型的对象
        //3.代码易于维护

        function Person1(name, age) {
            this.name = name
            this.age = age
        }
        //给Person1的原型增加一个方法，此方法会被构造函数所创建的对象实例所接受
        //做法是将需要独立的属性方法放入构造函数中，而可以共享的部分则放入原型中，这样做可以最大限度节省内存而又保留对象实例的独立性。
        Person1.prototype.say = function () {
            console.log(`hello i am ${this.name}`)
        }
        let tom = new Person1('tom', 20)

        var arr = new Array('a', 'b', 'c')
        /*-----------对象的基本操作------------*/
        var hero = {
            name: "李白",
            skill: "青莲剑歌",
            zb:"三相之力"
        }
        //修改
        hero.name = "德玛西亚"
        //增加
        hero.skill = ['旋转跳跃','大保健']
        //删除
        delete hero.zb //直接把zb这个键值对删除
        //hero.zb = null //把zb键对应的值设为空
        //查
        hero.name
        hero[name]
        var key = 'name'
        hero.key //undifined
        hero[key]//"德玛西亚"
        


    </script>
</body>

</html>